home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / freeWAIS-sf-1.1 / ir / zprot.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-04  |  31.6 KB  |  1,154 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:`
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.    
  4. /*
  5.  
  6. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  7.  
  8.  
  9. #ifndef lint
  10. static char *RCSid = "$Header: /usr/local/ls6/src+data/src/freeWAIS-sf/ir/RCS/zprot.c,v 1.4 1994/08/05 07:13:01 pfeifer Exp $";
  11. #endif
  12.  
  13. /* Change log:
  14.  * $Log: zprot.c,v $
  15.  * Revision 1.4  1994/08/05  07:13:01  pfeifer
  16.  * Release beta 04
  17.  *
  18.  * Revision 1.3  1994/05/20  12:58:19  pfeifer
  19.  * beta
  20.  *
  21.  * Revision 1.2  1994/03/08  21:07:22  pfeifer
  22.  * Patchlevel 04
  23.  *
  24.  * Revision 1.1  1993/02/16  15:05:35  freewais
  25.  * Initial revision
  26.  *
  27.  * Revision 1.4  92/02/12  13:59:51  jonathan
  28.  * Added "$Log" so RCS will put the log message in the header
  29.  * 
  30.  * 
  31.   
  32.    3.26.90    Harry Morris, morris@think.com
  33.    3.30.90  Harry Morris - Changed any->bits to any->bytes
  34.    4.11.90  HWM - generalized conditional includes (see c-dialect.h)
  35. */
  36.  
  37. #define _C_Z39_50_
  38.  
  39. #include "zprot.h"
  40.  
  41. #include "zutil.h"
  42. #include "cutil.h"
  43. /*#include <string.h>*/
  44.  
  45. #ifndef ANSI_LIKE
  46. #include "ustubs.h"
  47. #endif
  48.  
  49. #define RESERVE_SPACE_FOR_HEADER(spaceLeft)        \
  50.     *spaceLeft -= HEADER_LEN;
  51.     
  52. #define RELEASE_HEADER_SPACE(spaceLeft)            \
  53.     if (*spaceLeft > 0)                            \
  54.       *spaceLeft += HEADER_LEN;
  55.     
  56. /*----------------------------------------------------------------------*/
  57.  
  58. InitAPDU* 
  59. makeInitAPDU(search,
  60.          present,
  61.          deleteIt,
  62.          accessControl,
  63.          resourceControl,
  64.          prefSize,
  65.          maxMsgSize,
  66.          auth,
  67.          id,
  68.          name,
  69.          version,
  70.          refID,
  71.          userInfo)
  72. boolean search;
  73. boolean present;
  74. boolean deleteIt;
  75. boolean accessControl;
  76. boolean resourceControl;
  77. long prefSize;
  78. long maxMsgSize;
  79. char* auth;
  80. char* id;
  81. char* name;
  82. char* version;
  83. any* refID;
  84. void* userInfo;
  85.  
  86. /* build an init APDU with user specified information */
  87. { 
  88.   InitAPDU* init = (InitAPDU*)s_malloc((size_t)sizeof(InitAPDU));
  89.  
  90.   init->PDUType = initAPDU;
  91.   init->willSearch = search;
  92.   init->willPresent = present;
  93.   init->willDelete = deleteIt;
  94.   init->supportAccessControl = accessControl;
  95.   init->supportResourceControl = resourceControl;
  96.   init->PreferredMessageSize = prefSize;
  97.   init->MaximumRecordSize = maxMsgSize;
  98.   init->IDAuthentication = s_strdup(auth);
  99.   init->ImplementationID = s_strdup(id);
  100.   init->ImplementationName = s_strdup(name);
  101.   init->ImplementationVersion = s_strdup(version);
  102.   init->ReferenceID = duplicateAny(refID);
  103.   init->UserInformationField = userInfo; /* not copied */
  104.   
  105.   return(init);
  106. }
  107.  
  108. /*----------------------------------------------------------------------*/
  109.  
  110. void 
  111. freeInitAPDU(init)
  112. InitAPDU* init;
  113. /* free an initAPDU */
  114. {
  115.   s_free(init->IDAuthentication);
  116.   s_free(init->ImplementationID);
  117.   s_free(init->ImplementationName);
  118.   s_free(init->ImplementationVersion);
  119.   freeAny(init->ReferenceID);
  120.   s_free(init);
  121. }
  122.  
  123. /*----------------------------------------------------------------------*/
  124.  
  125. char* 
  126. writeInitAPDU(init,buffer,len)
  127. InitAPDU* init;
  128. char* buffer;
  129. long* len;
  130. /* write the init to a buffer, adding system information */
  131. {
  132.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  133.   long size;
  134.   bit_map* optionsBM = NULL;
  135.  
  136.   RESERVE_SPACE_FOR_HEADER(len);
  137.   
  138.   buf = writePDUType(init->PDUType,buf,len);
  139.   
  140.   buf = writeProtocolVersion(buf,len);
  141.   
  142.   optionsBM = makeBitMap((unsigned long)5,init->willSearch,init->willPresent,
  143.                          init->willDelete,init->supportAccessControl,
  144.                          init->supportResourceControl);
  145.   buf = writeBitMap(optionsBM,DT_Options,buf,len);
  146.   freeBitMap(optionsBM);
  147.  
  148.   buf = writeNum(init->PreferredMessageSize,DT_PreferredMessageSize,buf,len);
  149.   buf = writeNum(init->MaximumRecordSize,DT_MaximumRecordSize,buf,len);
  150.   buf = writeString(init->IDAuthentication,DT_IDAuthentication,buf,len);
  151.   buf = writeString(init->ImplementationID,DT_ImplementationID,buf,len);
  152.   buf = writeString(init->ImplementationName,DT_ImplementationName,buf,len);
  153.   buf = writeString(init->ImplementationVersion,DT_ImplementationVersion,buf,len);
  154.   buf = writeAny(init->ReferenceID,DT_ReferenceID,buf,len);
  155.   
  156.   /* go back and write the header-length-indicator */
  157.   RELEASE_HEADER_SPACE(len);
  158.   size = buf - buffer - HEADER_LEN; 
  159.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  160.  
  161.   if (init->UserInformationField != NULL)
  162.     buf = writeInitInfo(init,buf,len);   
  163.     
  164.   return(buf); 
  165. }
  166.  
  167. /*----------------------------------------------------------------------*/
  168.  
  169. char* 
  170. readInitAPDU(init,buffer)
  171. InitAPDU** init;
  172. char* buffer;
  173. {
  174.   char* buf = buffer;
  175.   boolean search,present,delete,accessControl,resourceControl;
  176.   long prefSize,maxMsgSize;
  177.   char *auth,*id,*name,*version;
  178.   long size; 
  179.   pdu_type pduType;
  180.   bit_map* versionBM = NULL;
  181.   bit_map* optionsBM = NULL;
  182.   any *refID = NULL;
  183.   void* userInfo = NULL;
  184.   
  185.   auth = id = name = version = NULL;
  186.   
  187.   /* read required part */
  188.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  189.   buf = readPDUType(&pduType,buf);
  190.   buf = readBitMap(&versionBM,buf); 
  191.   buf = readBitMap(&optionsBM,buf);
  192.   buf = readNum(&prefSize,buf);
  193.   buf = readNum(&maxMsgSize,buf);
  194.   
  195.   /* decode optionsBM */
  196.   search = bitAtPos(0L,optionsBM);
  197.   present = bitAtPos(1L,optionsBM);
  198.   delete = bitAtPos(2L,optionsBM);
  199.   accessControl = bitAtPos(3L,optionsBM);
  200.   resourceControl = bitAtPos(4L,optionsBM);
  201.   
  202.   /* read optional part */
  203.   while (buf < (buffer + size + HEADER_LEN)) 
  204.     { data_tag tag = peekTag(buf);
  205.       switch (tag)
  206.     { case DT_IDAuthentication:
  207.         buf = readString(&auth,buf);
  208.         break;
  209.       case DT_ImplementationID:
  210.         buf = readString(&id,buf);
  211.         break;
  212.       case DT_ImplementationName:
  213.         buf = readString(&name,buf);
  214.         break;
  215.       case DT_ImplementationVersion:
  216.         buf = readString(&version,buf);
  217.         break;
  218.       case DT_ReferenceID:
  219.         buf = readAny(&refID,buf);
  220.         break;
  221.       default:
  222.         freeBitMap(versionBM);
  223.         freeBitMap(optionsBM);
  224.         s_free(auth);
  225.         s_free(id);
  226.         s_free(name);
  227.         s_free(version);
  228.         freeAny(refID);
  229.         REPORT_READ_ERROR(buf);
  230.         break;
  231.       }
  232.     }
  233.  
  234.   buf = readInitInfo(&userInfo,buf);
  235.   s_free(userInfo);
  236.   if (buf == NULL)
  237.     { freeBitMap(versionBM);
  238.       freeBitMap(optionsBM);
  239.       s_free(auth);
  240.       s_free(id);
  241.       s_free(name);
  242.       s_free(version);
  243.       freeAny(refID);
  244.     }
  245.   RETURN_ON_NULL(buf);
  246.  
  247.   /* construct the basic init object */
  248.   *init = makeInitAPDU(search,present,delete,accessControl,resourceControl,
  249.                        prefSize,maxMsgSize,auth,id,name,version,refID,userInfo);
  250.                           
  251.   freeBitMap(versionBM);
  252.   freeBitMap(optionsBM);
  253.   s_free(auth);
  254.   s_free(id);
  255.   s_free(name);
  256.   s_free(version);
  257.   freeAny(refID);
  258.   
  259.   return(buf);
  260. }
  261.  
  262. /*----------------------------------------------------------------------*/
  263.  
  264. InitResponseAPDU* 
  265. makeInitResponseAPDU(result,
  266.              search,
  267.              present,
  268.              deleteIt,
  269.              accessControl,
  270.              resourceControl,
  271.              prefSize,
  272.              maxMsgSize,
  273.              auth,
  274.              id,
  275.              name,
  276.              version,
  277.              refID,
  278.              userInfo)
  279. boolean result;
  280. boolean search;
  281. boolean present;
  282. boolean deleteIt;
  283. boolean accessControl;
  284. boolean resourceControl;
  285. long prefSize;
  286. long maxMsgSize;
  287. char* auth;
  288. char* id;
  289. char* name;
  290. char* version;
  291. any* refID;
  292. void* userInfo;
  293. /* build an initResponse APDU with user specified information */
  294. { 
  295.   InitResponseAPDU* init = (InitResponseAPDU*)s_malloc((size_t)sizeof(InitResponseAPDU));
  296.  
  297.   init->PDUType = initResponseAPDU;
  298.   init->Result = result;
  299.   init->willSearch = search;
  300.   init->willPresent = present;
  301.   init->willDelete = deleteIt;
  302.   init->supportAccessControl = accessControl;
  303.   init->supportResourceControl = resourceControl;
  304.   init->PreferredMessageSize = prefSize;
  305.   init->MaximumRecordSize = maxMsgSize;
  306.   init->IDAuthentication = s_strdup(auth);
  307.   init->ImplementationID = s_strdup(id);
  308.   init->ImplementationName = s_strdup(name);
  309.   init->ImplementationVersion = s_strdup(version);
  310.   init->ReferenceID = duplicateAny(refID);
  311.   init->UserInformationField = userInfo; /* not copied! */
  312.   
  313.   return(init);
  314. }
  315.  
  316. /*----------------------------------------------------------------------*/
  317.  
  318. void 
  319. freeInitResponseAPDU(init)
  320. InitResponseAPDU* init;
  321. /* free an initAPDU */
  322. {
  323.   s_free(init->IDAuthentication);
  324.   s_free(init->ImplementationID);
  325.   s_free(init->ImplementationName);
  326.   s_free(init->ImplementationVersion);
  327.   freeAny(init->ReferenceID);
  328.   s_free(init);
  329. }
  330.  
  331. /*----------------------------------------------------------------------*/
  332.  
  333. char* 
  334. writeInitResponseAPDU(init,buffer,len)
  335. InitResponseAPDU* init;
  336. char* buffer;
  337. long* len;
  338. /* write the initResponse to a buffer, adding system information */
  339. { 
  340.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  341.   long size;
  342.   bit_map* optionsBM = NULL;
  343.  
  344.   RESERVE_SPACE_FOR_HEADER(len);
  345.   
  346.   buf = writePDUType(init->PDUType,buf,len);
  347.   buf = writeBoolean(init->Result,buf,len);
  348.   buf = writeProtocolVersion(buf,len);
  349.   
  350.   optionsBM = makeBitMap((unsigned long)5,init->willSearch,init->willPresent,
  351.                          init->willDelete,init->supportAccessControl,
  352.                          init->supportResourceControl);
  353.   buf = writeBitMap(optionsBM,DT_Options,buf,len);
  354.   freeBitMap(optionsBM);
  355.  
  356.   buf = writeNum(init->PreferredMessageSize,DT_PreferredMessageSize,buf,len);
  357.   buf = writeNum(init->MaximumRecordSize,DT_MaximumRecordSize,buf,len);
  358.   buf = writeString(init->IDAuthentication,DT_IDAuthentication,buf,len);
  359.   buf = writeString(init->ImplementationID,DT_ImplementationID,buf,len);
  360.   buf = writeString(init->ImplementationName,DT_ImplementationName,buf,len);
  361.   buf = writeString(init->ImplementationVersion,DT_ImplementationVersion,buf,len);
  362.   buf = writeAny(init->ReferenceID,DT_ReferenceID,buf,len);
  363.   
  364.   /* go back and write the header-length-indicator */
  365.   RELEASE_HEADER_SPACE(len);
  366.   size = buf - buffer - HEADER_LEN; 
  367.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  368.  
  369.   if (init->UserInformationField != NULL)
  370.     buf = writeInitResponseInfo(init,buf,len);   
  371.     
  372.   return(buf);
  373. }
  374.  
  375. /*----------------------------------------------------------------------*/
  376.  
  377. char* 
  378. readInitResponseAPDU(init,buffer)
  379. InitResponseAPDU** init;
  380. char* buffer;
  381. {
  382.   char* buf = buffer;
  383.   boolean search,present,delete,accessControl,resourceControl;
  384.   long prefSize,maxMsgSize;
  385.   char *auth,*id,*name,*version;
  386.   long size; 
  387.   pdu_type pduType;
  388.   bit_map* versionBM = NULL;
  389.   bit_map* optionsBM = NULL;
  390.   boolean result;
  391.   any *refID = NULL;
  392.   void* userInfo = NULL;
  393.   
  394.   auth = id = name = version = NULL;
  395.   refID = NULL;
  396.   
  397.   /* read required part */
  398.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  399.   buf = readPDUType(&pduType,buf);
  400.   buf = readBoolean(&result,buf);
  401.   buf = readBitMap(&versionBM,buf); 
  402.   buf = readBitMap(&optionsBM,buf);
  403.   buf = readNum(&prefSize,buf);
  404.   buf = readNum(&maxMsgSize,buf);
  405.   
  406.   /* decode optionsBM */
  407.   search = bitAtPos(0L,optionsBM);
  408.   present = bitAtPos(1L,optionsBM);
  409.   delete = bitAtPos(2L,optionsBM);
  410.   accessControl = bitAtPos(3L,optionsBM);
  411.   resourceControl = bitAtPos(4L,optionsBM);
  412.   
  413.   /* read optional part */
  414.   while (buf < (buffer + size + HEADER_LEN)) 
  415.     { data_tag tag = peekTag(buf);
  416.       switch (tag)
  417.     { case DT_IDAuthentication:
  418.         buf = readString(&auth,buf);
  419.         break;
  420.       case DT_ImplementationID:
  421.         buf = readString(&id,buf);
  422.         break;
  423.       case DT_ImplementationName:
  424.         buf = readString(&name,buf);
  425.         break;
  426.       case DT_ImplementationVersion:
  427.         buf = readString(&version,buf);
  428.         break;
  429.       case DT_ReferenceID:
  430.         buf = readAny(&refID,buf);
  431.         break;
  432.       default:
  433.         freeBitMap(versionBM);
  434.         freeBitMap(optionsBM);
  435.         s_free(auth);
  436.         s_free(id);
  437.         s_free(name);
  438.         s_free(version);
  439.         freeAny(refID);
  440.         REPORT_READ_ERROR(buf);
  441.         break;
  442.       }
  443.     }
  444.  
  445.   buf = readInitResponseInfo(&userInfo,buf);
  446.   if (buf == NULL)
  447.     { freeBitMap(versionBM);
  448.       freeBitMap(optionsBM);
  449.       s_free(auth);
  450.       s_free(id);
  451.       s_free(name);
  452.       s_free(version);
  453.       freeAny(refID);
  454.     }
  455.   RETURN_ON_NULL(buf);
  456.   
  457.   /* construct the basic init object */
  458.   *init = makeInitResponseAPDU(result,
  459.                    search,present,delete,accessControl,resourceControl,
  460.                    prefSize,maxMsgSize,auth,id,name,version,refID,userInfo);
  461.                                           
  462.   freeBitMap(versionBM);
  463.   freeBitMap(optionsBM);
  464.   s_free(auth);
  465.   s_free(id);
  466.   s_free(name);
  467.   s_free(version);
  468.   freeAny(refID);
  469.   
  470.   return(buf);
  471. }
  472.  
  473. /*----------------------------------------------------------------------*/
  474.  
  475. InitResponseAPDU* 
  476. replyToInitAPDU(init,result,userInfo)
  477. InitAPDU* init;
  478. boolean result;
  479. void* userInfo;
  480. /* respond to an init message in the default way - echoing back
  481.    the init info 
  482.  */
  483. {
  484.   InitResponseAPDU* initResp;
  485.   initResp = makeInitResponseAPDU(result,
  486.                   init->willSearch,init->willPresent,init->willDelete,
  487.                   init->supportAccessControl,init->supportResourceControl,
  488.                   init->PreferredMessageSize,init->MaximumRecordSize,
  489.                   init->IDAuthentication,defaultImplementationID(),defaultImplementationName(),
  490.                   defaultImplementationVersion(),
  491.                   init->ReferenceID,userInfo);
  492.   return(initResp);
  493. }
  494.  
  495. /*----------------------------------------------------------------------*/
  496.  
  497. SearchAPDU* 
  498. makeSearchAPDU(small,
  499.            large,
  500.            medium,
  501.            replace,
  502.            name,
  503.            databases,
  504.            type,
  505.            elements,
  506.            refID,
  507.            queryInfo)
  508. long small;
  509. long large;
  510. long medium;
  511. boolean replace;
  512. char* name;
  513. char** databases;
  514. char* type;
  515. char** elements;
  516. any* refID;
  517. void* queryInfo;
  518. {
  519.   char* ptr = NULL;
  520.   long i;
  521.   SearchAPDU* query = (SearchAPDU*)s_malloc((size_t)sizeof(SearchAPDU));
  522.   query->PDUType = searchAPDU;
  523.   query->SmallSetUpperBound = small;
  524.   query->LargeSetLowerBound = large;
  525.   query->MediumSetPresentNumber = medium;
  526.   query->ReplaceIndicator = replace;
  527.   query->ResultSetName = s_strdup(name);
  528.   query->DatabaseNames = NULL; 
  529.   if (databases != NULL)
  530.     { for (i = 0, ptr = databases[i]; ptr != NULL; ptr = databases[++i])
  531.     { if (query->DatabaseNames == NULL)
  532.         query->DatabaseNames = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  533.         else
  534.           query->DatabaseNames = (char**)s_realloc((char*)query->DatabaseNames,
  535.                            (size_t)(sizeof(char*) * (i + 2)));
  536.         query->DatabaseNames[i] = s_strdup(ptr);
  537.         query->DatabaseNames[i+1] = NULL;
  538.       }
  539.       }
  540.   query->QueryType = s_strdup(type);
  541.   query->ElementSetNames = NULL; 
  542.   if (elements != NULL)
  543.     { for (i = 0, ptr = elements[i]; ptr != NULL; ptr = elements[++i])
  544.     { if (query->ElementSetNames == NULL)
  545.         query->ElementSetNames = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  546.         else
  547.           query->ElementSetNames = (char**)s_realloc((char*)query->ElementSetNames,
  548.                              (size_t)(sizeof(char*) * (i + 2)));
  549.         query->ElementSetNames[i] = s_strdup(ptr);
  550.         query->ElementSetNames[i+1] = NULL;
  551.       }
  552.       }
  553.   query->ReferenceID = duplicateAny(refID);
  554.   query->Query = queryInfo;    /* not copied! */
  555.   return(query);
  556. }
  557.  
  558. /*----------------------------------------------------------------------*/
  559.  
  560. void 
  561. freeSearchAPDU(query)
  562. SearchAPDU* query;
  563. {
  564.   s_free(query->ResultSetName);
  565.   s_free(query->QueryType);
  566.   doList((void**)query->DatabaseNames,fs_free); /* can't use the macro here ! */
  567.   s_free(query->DatabaseNames);
  568.   doList((void**)query->ElementSetNames,fs_free); /* can't use the macro here ! */
  569.   s_free(query->ElementSetNames);
  570.   freeAny(query->ReferenceID);
  571.   s_free(query);
  572. }
  573.  
  574. /*----------------------------------------------------------------------*/
  575.  
  576. #define DB_DELIMITER     "\037"     /* hex 1F occurs between each database name */
  577. #define ES_DELIMITER_1     "\037"     /* separates database name from element name */
  578. #define ES_DELIMITER_2     "\036"     /* hex 1E separates <db,es> groups from one another */
  579.  
  580. char* 
  581. writeSearchAPDU(query,buffer,len)
  582. SearchAPDU* query;
  583. char* buffer;
  584. long* len;
  585. { 
  586.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  587.   long size,i;
  588.   char* ptr = NULL;
  589.   char* scratch = NULL;
  590.  
  591.   RESERVE_SPACE_FOR_HEADER(len);
  592.   
  593.   buf = writePDUType(query->PDUType,buf,len);
  594.   buf = writeBinaryInteger(query->SmallSetUpperBound,(size_t)3,buf,len);
  595.   buf = writeBinaryInteger(query->LargeSetLowerBound,(size_t)3,buf,len);
  596.   buf = writeBinaryInteger(query->MediumSetPresentNumber,(size_t)3,buf,len);
  597.   buf = writeBoolean(query->ReplaceIndicator,buf,len);
  598.   buf = writeString(query->ResultSetName,DT_ResultSetName,buf,len);
  599.   /* write database names */
  600.   if (query->DatabaseNames != NULL)
  601.     { for (i = 0,scratch = NULL, ptr = query->DatabaseNames[i]; ptr != NULL; ptr = query->DatabaseNames[++i])
  602.     { if (scratch == NULL)
  603.         scratch = s_strdup(ptr);
  604.         else
  605.       { size_t newScratchSize = (size_t)(strlen(scratch) + strlen(ptr) + 3);
  606.         scratch = (char*)s_realloc(scratch,newScratchSize);
  607.         s_strncat(scratch,DB_DELIMITER,2L,newScratchSize);
  608.         s_strncat(scratch,ptr,strlen(ptr) + 1,newScratchSize);
  609.       }
  610.       }
  611.     buf = writeString(scratch,DT_DatabaseNames,buf,len);
  612.     s_free(scratch);
  613.       }
  614.   buf = writeString(query->QueryType,DT_QueryType,buf,len);
  615.   /* write element set names */
  616.   if (query->ElementSetNames != NULL)
  617.     { for (i = 0,scratch = NULL, ptr = query->ElementSetNames[i]; ptr != NULL; ptr = query->ElementSetNames[++i])
  618.     { if (scratch == NULL)
  619.         { if (query->ElementSetNames[i+1] == NULL) /* there is a single element set name */
  620.         { scratch = (char*)s_malloc((size_t)strlen(ptr) + 3);
  621.           strncpy(scratch,ES_DELIMITER_1,2);
  622.           s_strncat(scratch,ptr,strlen(ptr) + 1,strlen(ptr) + 2);
  623.         }
  624.         else        /* this is the first of a series of element set names */
  625.           { size_t newScratchSize = (size_t)(strlen(ptr) + strlen(query->ElementSetNames[i + 1]) + 3);
  626.         scratch = s_strdup(ptr); /* the database name */
  627.         ptr = query->ElementSetNames[++i]; /* the element set name */
  628.         scratch = (char*)s_realloc(scratch,newScratchSize);
  629.         s_strncat(scratch,ES_DELIMITER_1,2L,newScratchSize);
  630.         s_strncat(scratch,ptr,strlen(ptr) + 1,newScratchSize); 
  631.           }
  632.           }
  633.         else
  634.       { char* esPtr = query->ElementSetNames[++i]; /* the element set name */
  635.         size_t newScratchSize = (size_t)(strlen(scratch) + strlen(ptr) + strlen(esPtr) + 3);
  636.         scratch = (char*)s_realloc(scratch,newScratchSize);
  637.         s_strncat(scratch,ES_DELIMITER_2,2L,newScratchSize);
  638.         s_strncat(scratch,ptr,strlen(ptr) + 1,newScratchSize);
  639.         s_strncat(scratch,ES_DELIMITER_1,2L,newScratchSize);
  640.         s_strncat(scratch,esPtr,strlen(esPtr) + 1,newScratchSize); 
  641.       }
  642.       }
  643.     buf = writeString(scratch,DT_ElementSetNames,buf,len);
  644.     s_free(scratch);
  645.       }                        
  646.   buf = writeAny(query->ReferenceID,DT_ReferenceID,buf,len);
  647.     
  648.   /* go back and write the header-length-indicator */
  649.   RELEASE_HEADER_SPACE(len);
  650.   size = buf - buffer - HEADER_LEN; 
  651.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  652.  
  653.   if (query->Query != NULL)
  654.     buf = writeSearchInfo(query,buf,len);    
  655.     
  656.   return(buf);
  657. }
  658.  
  659. /*----------------------------------------------------------------------*/
  660.  
  661. char*
  662. readSearchAPDU(query,buffer)
  663. SearchAPDU** query;
  664. char* buffer;
  665. {
  666.   char* buf = buffer;
  667.   long size;
  668.   pdu_type pduType;
  669.   long small,large,medium,numItems;
  670.   boolean replace;
  671.   char *name,*databaseNames,*type,*elements;
  672.   char **dbList,**elemList;
  673.   any *refID;
  674.   void* userInfo = NULL;
  675.   
  676.   name = databaseNames = type = elements = NULL;
  677.   dbList = elemList = NULL;
  678.   refID = NULL;
  679.  
  680.   /* read required part */
  681.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  682.   buf = readPDUType(&pduType,buf);
  683.   buf = readBinaryInteger(&small,(size_t)3,buf);
  684.   buf = readBinaryInteger(&large,(size_t)3,buf);
  685.   buf = readBinaryInteger(&medium,(size_t)3,buf);
  686.   buf = readBoolean(&replace,buf);
  687.   
  688.   /* read optional part */
  689.   while (buf < (buffer + size + HEADER_LEN)) 
  690.     { data_tag tag = peekTag(buf);
  691.       switch (tag)
  692.     { case DT_ResultSetName:
  693.         buf = readString(&name,buf);
  694.         break;
  695.       case DT_DatabaseNames:
  696.         {            /* parse the database names */
  697.           char *tok;
  698.           buf = readString(&databaseNames,buf);
  699.           tok = strtok(databaseNames,DB_DELIMITER);
  700.           numItems = 0;
  701.           while (tok != NULL)
  702.         { if (dbList == NULL)
  703.             dbList = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  704.         else
  705.           dbList = (char**)s_realloc((char*)dbList,(size_t)(sizeof(char*) * (numItems+2)));
  706.             dbList[numItems++] = s_strdup(tok);
  707.             dbList[numItems] = NULL;
  708.             tok = strtok(NULL,DB_DELIMITER);
  709.           }
  710.         }
  711.         break;
  712.       case DT_QueryType:
  713.         buf = readString(&type,buf);
  714.         break;
  715.       case DT_ElementSetNames:
  716.         {            /* parse the element set names */
  717.           char *tok;
  718.           buf = readString(&elements,buf);
  719.           if (elements[0] == ES_DELIMITER_1[0]) /* this is a single element w/ no db */
  720.         { elemList = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  721.           elemList[0] = s_strdup(elements);
  722.           elemList[1] = NULL;
  723.         }
  724.           else        /* its a group of <DB/ES> pairs */
  725.         { char* esTok = NULL;
  726.           tok = strtok(elements,ES_DELIMITER_1); /* db name */
  727.           esTok = strtok(NULL,ES_DELIMITER_2); /* es name */
  728.           numItems = 0;
  729.           while (tok != NULL)
  730.             { if (elemList == NULL)
  731.             elemList = (char**)s_malloc((size_t)(sizeof(char*) * 3));
  732.             else
  733.               elemList = (char**)s_realloc((char*)elemList,(size_t)(sizeof(char*) * (numItems * 2 + 1)));
  734.             elemList[numItems++] = s_strdup(tok);
  735.             elemList[numItems++] = s_strdup(esTok);
  736.             elemList[numItems] = NULL;
  737.             tok = strtok(NULL,ES_DELIMITER_1);
  738.             esTok = strtok(NULL,ES_DELIMITER_2);
  739.               } 
  740.         }
  741.         }
  742.         break;
  743.       case DT_ReferenceID:
  744.         buf = readAny(&refID,buf);
  745.         break;
  746.       default:
  747.         s_free(name);
  748.         s_free(type);
  749.         s_free(databaseNames);
  750.         doList((void**)dbList,fs_free);
  751.         s_free(dbList);
  752.         s_free(elements);
  753.         doList((void**)elemList,fs_free);
  754.         s_free(elemList);
  755.         freeAny(refID);
  756.         REPORT_READ_ERROR(buf);
  757.         break;
  758.       }
  759.     }
  760.   
  761.   buf = readSearchInfo(&userInfo,buf);
  762.   if (buf == NULL)
  763.     { s_free(name);
  764.       s_free(type);
  765.       s_free(databaseNames);
  766.       doList((void**)dbList,fs_free);
  767.       s_free(dbList);
  768.       s_free(elements);
  769.       doList((void**)elemList,fs_free);
  770.       s_free(elemList);
  771.       freeAny(refID);
  772.     }
  773.   RETURN_ON_NULL(buf);
  774.     
  775.   /* construct the search object */
  776.   *query = makeSearchAPDU(small,large,medium,replace,name,dbList,type,elemList,refID,userInfo);
  777.  
  778.   s_free(name);
  779.   s_free(type);
  780.   s_free(databaseNames);
  781.   doList((void**)dbList,fs_free);
  782.   s_free(dbList);
  783.   s_free(elements);
  784.   doList((void**)elemList,fs_free);
  785.   s_free(elemList);
  786.   freeAny(refID);
  787.   
  788.   return(buf);
  789. }
  790.  
  791. /*----------------------------------------------------------------------*/
  792.  
  793. SearchResponseAPDU* 
  794. makeSearchResponseAPDU(result,count,recordsReturned,nextPos,resultStatus,
  795.                presentStatus,refID,records)
  796. long result;
  797. long count;
  798. long recordsReturned;
  799. long nextPos;
  800. long resultStatus;
  801. long presentStatus;
  802. any* refID;
  803. void* records;
  804. {
  805.   SearchResponseAPDU* query = (SearchResponseAPDU*)s_malloc((size_t)sizeof(SearchResponseAPDU));
  806.   query->PDUType = searchResponseAPDU;
  807.   query->SearchStatus = result;
  808.   query->ResultCount = count;
  809.   query->NumberOfRecordsReturned = recordsReturned;
  810.   query->NextResultSetPosition = nextPos;
  811.   query->ResultSetStatus = resultStatus;
  812.   query->PresentStatus = presentStatus;
  813.   query->ReferenceID = duplicateAny(refID);
  814.   query->DatabaseDiagnosticRecords = records;
  815.   return(query);  
  816. }
  817.  
  818. /*----------------------------------------------------------------------*/
  819.  
  820. void 
  821. freeSearchResponseAPDU(queryResponse)
  822. SearchResponseAPDU* queryResponse;
  823. {
  824.   freeAny(queryResponse->ReferenceID);
  825.   s_free(queryResponse);
  826. }
  827.  
  828. /*----------------------------------------------------------------------*/
  829.  
  830. char* 
  831. writeSearchResponseAPDU(queryResponse,buffer,len)
  832. SearchResponseAPDU* queryResponse;
  833. char* buffer;
  834. long* len;
  835. {
  836.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  837.   long size;
  838.  
  839.   RESERVE_SPACE_FOR_HEADER(len);
  840.   
  841.   buf = writePDUType(queryResponse->PDUType,buf,len);
  842.   buf = writeBinaryInteger(queryResponse->SearchStatus,(size_t)1,buf,len);
  843.   buf = writeBinaryInteger(queryResponse->ResultCount,(size_t)3,buf,len);
  844.   buf = writeBinaryInteger(queryResponse->NumberOfRecordsReturned,(size_t)3,buf,len);
  845.   buf = writeBinaryInteger(queryResponse->NextResultSetPosition,(size_t)3,buf,len);
  846.   buf = writeNum(queryResponse->ResultSetStatus,DT_ResultSetStatus,buf,len);
  847.   buf = writeNum(queryResponse->PresentStatus,DT_PresentStatus,buf,len);
  848.   buf = writeAny(queryResponse->ReferenceID,DT_ReferenceID,buf,len);
  849.     
  850.   /* go back and write the header-length-indicator */
  851.   RELEASE_HEADER_SPACE(len);
  852.   size = buf - buffer - HEADER_LEN; 
  853.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  854.  
  855.   if (queryResponse->DatabaseDiagnosticRecords != NULL)
  856.     buf = writeSearchResponseInfo(queryResponse,buf,len);    
  857.     
  858.   return(buf);
  859. }
  860.  
  861. /*----------------------------------------------------------------------*/
  862.  
  863. char* 
  864. readSearchResponseAPDU(queryResponse,buffer)
  865. SearchResponseAPDU** queryResponse;
  866. char* buffer;
  867. {
  868.   char* buf = buffer;
  869.   long size;
  870.   pdu_type pduType;
  871.   long result,count,recordsReturned,nextPos;
  872.   long resultStatus,presentStatus;
  873.   any *refID = NULL;
  874.   void* userInfo = NULL;
  875.   
  876.   /* read required part */
  877.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  878.   buf = readPDUType(&pduType,buf);
  879.   buf = readBinaryInteger(&result,(size_t)1,buf);
  880.   buf = readBinaryInteger(&count,(size_t)3,buf);
  881.   buf = readBinaryInteger(&recordsReturned,(size_t)3,buf);
  882.   buf = readBinaryInteger(&nextPos,(size_t)3,buf);
  883.   
  884.   resultStatus = presentStatus = UNUSED;
  885.   refID = NULL;
  886.  
  887.   /* read optional part */
  888.   while (buf < (buffer + size + HEADER_LEN)) 
  889.     { data_tag tag = peekTag(buf);
  890.       switch (tag)
  891.     { case DT_ResultSetStatus:
  892.         buf = readNum(&resultStatus,buf);
  893.         break;
  894.       case DT_PresentStatus:
  895.         buf = readNum(&presentStatus,buf);
  896.         break;
  897.       case DT_ReferenceID:
  898.         buf = readAny(&refID,buf);
  899.         break;
  900.       default:
  901.         freeAny(refID);
  902.         REPORT_READ_ERROR(buf);
  903.         break;
  904.       }
  905.     }
  906.   
  907.   buf = readSearchResponseInfo(&userInfo,buf);
  908.   if (buf == NULL)
  909.     freeAny(refID);
  910.   RETURN_ON_NULL(buf);
  911.   
  912.   /* construct the search object */
  913.   *queryResponse = makeSearchResponseAPDU(result,count,recordsReturned,nextPos,
  914.                       (long)resultStatus,(long)presentStatus,refID,userInfo);
  915.  
  916.   freeAny(refID);
  917.   
  918.   return(buf);
  919. }
  920.  
  921. #ifdef NOTUSED
  922. /*----------------------------------------------------------------------*/
  923.  
  924.  
  925. PresentAPDU* 
  926. makePresentAPDU(recsReq,startPos,resultID,refID,info)
  927. long recsReq;
  928. long startPos;
  929. char* resultID;
  930. any* refID;
  931. void* info;
  932. {
  933.   PresentAPDU* present = (PresentAPDU*)s_malloc((size_t)sizeof(PresentAPDU));
  934.   present->PDUType = presentAPDU;
  935.   present->NumberOfRecordsRequested = recsReq;
  936.   present->ResultSetStartPosition = startPos;
  937.   present->ResultSetID = s_strdup(resultID);
  938.   present->ElementSetNames = NULL; /* XXX for now */
  939.   present->ReferenceID = duplicateAny(refID);
  940.   present->PresentInfo = info;
  941.   return(present);  
  942. }
  943.  
  944. /*----------------------------------------------------------------------*/
  945.  
  946. void 
  947. freePresentAPDU(present)
  948. PresentAPDU* present;
  949. {
  950.   /* handle element set names */ 
  951.   s_free(present->ResultSetID);
  952.   freeAny(present->ReferenceID);
  953.   s_free(present);
  954. }
  955.  
  956. /*----------------------------------------------------------------------*/
  957.  
  958. char* 
  959. writePresentAPDU(present,buffer,len)
  960. PresentAPDU* present;
  961. char* buffer;
  962. long* len;
  963. {
  964.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  965.   long size;
  966.  
  967.   RESERVE_SPACE_FOR_HEADER(len);
  968.   
  969.   buf = writePDUType(present->PDUType,buf,len);
  970.   buf = writeBinaryInteger(present->NumberOfRecordsRequested,(size_t)3,buf,len);
  971.   buf = writeBinaryInteger(present->ResultSetStartPosition,(size_t)3,buf,len);
  972.   buf = writeString(present->ResultSetID,DT_ResultSetID,buf,len); 
  973.   /* handle element set names */
  974.   buf = writeAny(present->ReferenceID,DT_ReferenceID,buf,len);
  975.     
  976.   /* go back and write the header-length-indicator */
  977.   RELEASE_HEADER_SPACE(len);
  978.   size = buf - buffer - HEADER_LEN; 
  979.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  980.  
  981.   if (present->PresentInfo != NULL)
  982.     buf = writePresentInfo(present,buf,len);   
  983.     
  984.   return(buf); 
  985. }
  986.  
  987. /*----------------------------------------------------------------------*/
  988.  
  989. char* 
  990. readPresentAPDU(present,buffer)
  991. PresentAPDU** present;
  992. char* buffer;
  993. {
  994.   char* buf = buffer;
  995.   long size;
  996.   pdu_type pduType;
  997.   long recsReq,startPos;
  998.   char* resultID = NULL;
  999.   any *refID = NULL;
  1000.   void* userInfo = NULL;
  1001.   
  1002.   /* read required part */
  1003.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  1004.   buf = readPDUType(&pduType,buf);
  1005.   buf = readBinaryInteger(&recsReq,(size_t)3,buf);
  1006.   buf = readBinaryInteger(&startPos,(size_t)3,buf);
  1007.   buf = readString(&resultID,buf);
  1008.   
  1009.   /* read optional part */
  1010.   while (buf < (buffer + size + HEADER_LEN)) 
  1011.    { data_tag tag = peekTag(buf);
  1012.      switch (tag)
  1013.       { case DT_ReferenceID:
  1014.           buf = readAny(&refID,buf);
  1015.           break;
  1016.         default:
  1017.           s_free(resultID);
  1018.           freeAny(refID);
  1019.           REPORT_READ_ERROR(buf);
  1020.           break;
  1021.       }
  1022.    }
  1023.   
  1024.   buf = readPresentInfo(&userInfo,buf);
  1025.   if (buf == NULL)
  1026.    { s_free(resultID);
  1027.      freeAny(refID);
  1028.    }
  1029.   RETURN_ON_NULL(buf);
  1030.  
  1031.   /* construct the present object */
  1032.   *present = makePresentAPDU(recsReq,startPos,resultID,refID,userInfo);
  1033.  
  1034.   s_free(resultID);
  1035.   freeAny(refID);
  1036.   
  1037.   return(buf);
  1038. }
  1039.  
  1040. /*----------------------------------------------------------------------*/
  1041.  
  1042.  
  1043. PresentResponseAPDU* 
  1044. makePresentResponseAPDU(status,recsRet,nextPos,refID,records)
  1045. boolean status;
  1046. long recsRet;
  1047. long nextPos;
  1048. any* refID;
  1049. void* records;
  1050. {
  1051.   PresentResponseAPDU* present = (PresentResponseAPDU*)s_malloc((size_t)sizeof(PresentResponseAPDU));
  1052.   present->PDUType = presentResponseAPDU;
  1053.   present->PresentStatus = status;
  1054.   present->NumberOfRecordsReturned = recsRet;
  1055.   present->NextResultSetPosition = nextPos;
  1056.   present->ReferenceID = duplicateAny(refID);
  1057.   present->DatabaseDiagnosticRecords = records;
  1058.   return(present);  
  1059. }
  1060.  
  1061. /*----------------------------------------------------------------------*/
  1062.  
  1063. void 
  1064. freePresentResponseAPDU(present)
  1065. PresentResponseAPDU* present;
  1066. { 
  1067.   freeAny(present->ReferenceID);
  1068.   s_free(present);
  1069. }
  1070.  
  1071. /*----------------------------------------------------------------------*/
  1072.  
  1073. char* 
  1074. writePresentResponseAPDU(present,buffer,len)
  1075. PresentResponseAPDU* present;
  1076. char* buffer;
  1077. long* len;
  1078. {
  1079.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  1080.   long size;
  1081.  
  1082.   RESERVE_SPACE_FOR_HEADER(len);
  1083.   
  1084.   buf = writePDUType(present->PDUType,buf,len);
  1085.   buf = writeBoolean(present->PresentStatus,buf,len);
  1086.   buf = writeBinaryInteger(present->NumberOfRecordsReturned,(size_t)3,buf,len);
  1087.   buf = writeBinaryInteger(present->NextResultSetPosition,(size_t)3,buf,len);
  1088.   buf = writeAny(present->ReferenceID,DT_ReferenceID,buf,len);
  1089.     
  1090.   /* go back and write the header-length-indicator */
  1091.   RELEASE_HEADER_SPACE(len);
  1092.   size = buf - buffer - HEADER_LEN; 
  1093.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  1094.  
  1095.   if (present->DatabaseDiagnosticRecords != NULL)
  1096.     buf = writePresentResponseInfo(present,buf,len);
  1097.     
  1098.   return(buf);
  1099. }
  1100.  
  1101. /*----------------------------------------------------------------------*/
  1102.  
  1103. char* 
  1104. readPresentResponseAPDU(present,buffer)
  1105. PresentResponseAPDU** present;
  1106. char* buffer;
  1107. {
  1108.   char* buf = buffer;
  1109.   long size;
  1110.   pdu_type pduType;
  1111.   boolean status;
  1112.   long recsRet,nextPos;
  1113.   any *refID = NULL;
  1114.   void* userInfo = NULL;
  1115.  
  1116.   /* read required part */
  1117.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  1118.   buf = readPDUType(&pduType,buf);
  1119.   buf = readBoolean(&status,buf);
  1120.   buf = readBinaryInteger(&recsRet,(size_t)3,buf);
  1121.   buf = readBinaryInteger(&nextPos,(size_t)3,buf);
  1122.  
  1123.   /* read optional part */
  1124.   while (buf < (buffer + size + HEADER_LEN)) 
  1125.    { data_tag tag = peekTag(buf);
  1126.      switch (tag)
  1127.       { case DT_ReferenceID:
  1128.           buf = readAny(&refID,buf);
  1129.           break;
  1130.         default:
  1131.           freeAny(refID);
  1132.           REPORT_READ_ERROR(buf);
  1133.           break;
  1134.       }
  1135.    }
  1136.   
  1137.   buf = readPresentResponseInfo(&userInfo,buf);
  1138.   if (buf == NULL)
  1139.     freeAny(refID);
  1140.   RETURN_ON_NULL(buf);
  1141.  
  1142.   /* construct the presentResponse object */
  1143.   *present = makePresentResponseAPDU(status,recsRet,nextPos,refID,userInfo);
  1144.  
  1145.   freeAny(refID);
  1146.   
  1147.   return(buf);
  1148. }
  1149.  
  1150. /*----------------------------------------------------------------------*/
  1151.  
  1152.  
  1153. #endif /* def NOTUSED */
  1154.